package main

func movingCount(m int, n int, k int) int {
	println("顶部")
	flag := make([][]int, m)

	for i:=0; i<m; i++ {
		flag[i] = make([]int, n)
	}
	sum := 0
	var helper func(i, j int)

	helper = func(i, j int) {
		println(i, j)
		if flag[i][j] == 1 {
			return
		}
		if cal(i, j) > k {
			return
		}
		sum++
		flag[i][j] = 1
		if i>0 {
			helper(i-1, j)
		}
		if j>0 {
			helper(i, j-1)
		}
		if i<m-1 {
			helper(i+1, j)
		}
		if j<n-1 {
			helper(i, j+1)
		}
	}

	println(m, m, 1)

	helper(0, 0)

	return sum
}

func cal(x, y int) int {
	sum := 0
	for x != 0 {
		println(x)
		sum += x % 10
		x /= 10
	}

	for y != 0 {
		println(y)
		sum += y % 10
		y /= 10
	}
	return sum
}

func main() {
	println("hello")
	movingCount(2, 3, 1)
}

//// 定义一个全局对象db
//var db *sql.DB
//
//// 定义一个初始化数据库的函数，也就是连接数据库
//func initDB() (err error) {
//	// DSN:Data Source Name
//	//dsn := "user:password@tcp(127.0.0.1:3306)/dbname" // 一般语句
//	dsn := "root:123456@tcp(127.0.0.1:3306)/runoob"  // 这是我电脑上的数据库，请根据实际情况自行修改
//	// 不会校验账号密码是否正确
//	// 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
//	db, err = sql.Open("mysql", dsn)
//	if err != nil {
//		return err
//	}
//	// 尝试与数据库建立连接（校验dsn是否正确）
//	err = db.Ping()
//	if err != nil {
//		return err
//	}
//	return nil
//}
//
//func main() {
//	err := initDB() // 调用输出化数据库的函数
//	if err != nil {
//		fmt.Printf("init db failed,err:%v\n", err)
//		return
//	}
//	// 将runoob1_tb1 这个表中的数据全部读出来
//	rows, err := db.Query("SELECT * FROM runoob_tb1")
//
//	// 也可以使用条件选择
//	//id := 2
//	//rows, err := db.Query("SELECT * FROM runoob_tb1 WHERE id=?", id) //
//
//	//
//	if err != nil {
//		log.Fatalln(err)
//	}
//	defer rows.Close()
//
//	for rows.Next() {
//		// 取多少个变量就定义多少个变量
//		var id int
//		var author string
//		var title string
//		var date string
//		if err := rows.Scan(&id, &title, &author, &date); err != nil {
//			log.Fatalln(err)
//		}
//		fmt.Println(id, title, author, date)
//	}
//	if err := rows.Err(); err != nil {
//		log.Fatalln(err)
//	}
//}



//package main
//
//func main()  {
//	str1 := "你好, Jack"
//	//str2 := "hello Mike"
//
//	for v := range str1 {
//		println(v)
//	}
//
//	for _, v := range str1 {
//		println(string(v))
//	}
//
//	//for k, v := range str2 {
//	//	println(k, v)
//	//}
//}

//func foo() *int {
//	a := 10
//	b := 20
//	fmt.Println(a)
//	return &b
//}

//func myAtoi(str string) int {
//	max := (1 << 32) - 1
//	min := -1 * (1 << 32)
//	flag := 1
//	// flag2 := false
//	ans := 0
//	for _, v := range str {
//		temp := int(v-'0')
//		if temp < 0 || temp > 9{
//			if ans != 0 {
//				break
//			} else if v=='-' {
//				flag = -1
//			}
//		} else {
//			println(temp)
//			ans = ans*10 + temp
//			if ans*flag > max {
//				return max
//			} else if ans*flag < min {
//				return min
//			}
//		}
//	}
//	return flag*ans
//}
//
//func main(){
//	//max := (1 << 31) -1
//	min := -1 * (1 << 32)
//	ans := "-42"
//	println(min, myAtoi(ans))
//}


//import (
//	"io"
//	"log"
//	"net/http"
//	"os"
//)
//
////
//func main()  {
//	r, err := http.Get(os.Args[1])
//	if err != nil {
//		log.Fatalln(err)
//	}
//
//	f, err := os.Create(os.Args[2])
//	if err != nil {
//		log.Fatalln(err)
//	}
//
//	io.Copy(f, r.Body)
//	if err = r.Body.Close(); err!=nil {
//		log.Println(err)
//	}
//}

//import (
//	"bytes"
//	"fmt"
//	"os"
//)
//
//func main() {
//	var b bytes.Buffer
//
//	b.Write([]byte("hello "))
//
//	fmt.Fprint(&b, "world")
//
//	b.WriteTo(os.Stdout)
//}

//var (
//	wg sync.WaitGroup
//)
//
//
//func init() {
//	log.SetPrefix("Trace: ")
//	log.SetFlags(log.Ldate | log.Lmicroseconds | log.Llongfile)
//}
//
//func main()  {
//	log.Println("你好")
//}

//func main()  {
//	u := test.User{
//		Name: "Mike",
//	}
//	fmt.Println(u)
//}

//func main()  {
//	var b bytes.Buffer
//
//	b.Write([]byte("hello"))
//	fmt.Fprint(&b, "world")
//
//	io.Copy(os.Stdout, &b)
//}
//func test(n, m, k int) int {
//	fmt.Println(n, m, k)
//	if m==n {
//		return 1
//	}
//	sum := 0
//	for i:=k; i<=n; i++ {
//		if m+i > n {
//			break
//		} else {
//			sum += test(n, m+i, i)
//		}
//	}
//	return sum
//}
//
//func main()  {
//	fmt.Println(test(4, 0, 1))
//
//	//nums := []int{1, 2, 3, 4, 5}
//	//new := nums[0:3]
//	//fmt.Println(new[4])
//
//	source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
//	// 对第三个元素做切片，并限制容量// 其长度和容量都是1个元素
//	slice := source[1:2:2]
//	slice = append(slice, "KiKi", "Pear")
//
//	fmt.Println(source, slice)
//
//
//	m := map[string]string{"China": "中国"}
//	v := m["Ame"]
//	fmt.Println(v)
//
//	var i1 int32 = 10
//	var i2 int64 = 10
//	i1 = i2
//}




//var m map[string]string
//func main()  {
//	val := m["get"]
//	if val == "" {
//		fmt.Println("is empty string")
//	}
//	fmt.Println(val)
//
//	strconv.Itoa()
//}



//// Employee 一个员工基类，每个员工都有自己的名字和编号
//type Employee struct {
//	Name string
//	id uint8
//}
//
//// T1 最高级别的员工，有普通薪水，奖金，股票分红
//type T1 struct {
//	Employee
//	Salary int
//	Bonus int
//	Stock int
//}
//
//// 每一种员工都有自己薪水的计算器
//// 对于T1级别的是基本薪水加上5倍年终奖以及百分之二十的股票分红
////func (t *T1) CalculatorForOne()  float32 {
////	return float32(t.Salary + 5*t.Bonus) + 0.2*float32(t.Stock)
////}
//
//func (t T1) CalculatorForOne()  float32 {
//	return float32(t.Salary + 5*t.Bonus) + 0.2*float32(t.Stock)
//}
//
//// T2级别的员工只有薪水和奖金
//type T2 struct {
//	Employee
//	Salary int
//	Bonus int
//}
//
//// 对于T2级别的是基本薪水加上3倍年终奖
////func (t *T2) CalculatorForOne()  float32 {
////	return float32(t.Salary + 3*t.Bonus)
////}
//
//func (t T2) CalculatorForOne()  float32 {
//	return float32(t.Salary + 3*t.Bonus)
//}
//
//// T2级别的员工只有薪水和奖金
//type T3 struct {
//	Employee
//	Salary int
//}
//
//// 对于T2级别的是基本薪水加上3倍年终奖
////func (t *T3) CalculatorForOne()  float32 {
////	return float32(t.Salary)
////}
//func (t T3) CalculatorForOne()  float32 {
//	return float32(t.Salary)
//}
//
//type Calculator interface {
//	CalculatorForOne()  float32
//}
//
//// 一个能够计算全体员工薪水的计算器
//func CalculatorForAll(c ...Calculator) (sum float32) {
//	for _, employee := range c {
//		sum += employee.CalculatorForOne()
//	}
//	return
//}
//
//type pSayer interface {
//	pSayHello()
//}
//
//type Sayer interface {
//	SayHello()
//}
//
//type myString string
//
//func (s *myString) pSayHello()  {
//	fmt.Println(*s, "say hello in p")
//}
//
//func (s myString) SayHello()  {
//	fmt.Println(s, "say hello")
//}
//
//
//
////func main()  {
////	s := myString("Mike")
////	ps := myString("Mary")
////
////	s.pSayHello()
////	s.SayHello()
////	ps.pSayHello()
////	ps.SayHello()
////}
//
//func Foo(values ...interface{})   {
//	for _, v := range values {
//		switch value := v.(type)  {
//		case int:
//			fmt.Println("这是一个整数，对它加倍：", 2*value)
//		case string:
//			fmt.Println("这是一个字符串，对它打招呼：", "hello " + value)
//		case bool:
//			fmt.Println("这是一个布尔类型，对它进行取反：", !value)
//		}
//	}
//}
//
//type Reader interface {
//	Read(s []byte) string
//}
//
//type Writer interface {
//	Write(s []byte) (int, string)
//}
//
//type ReadWriter interface {
//	Writer
//	Reader
//}
//
//type WriteReader interface {
//	Write(s []byte) (int, string)
//	Reader
//}
//
//func main()  {
//	var stack []interface{}
//	stack = append(stack, "你好啊", 11, true)
//
//	var intfs interface{}
//	i := 10
//	intfs = i
//	value1, ok := intfs.(bool)
//	fmt.Println(value1, ok)
//	value2, ok := intfs.(int)
//	fmt.Println(value2, ok)
//
//	Foo(stack...)
//
//	http.Handle()
//	http.HandleFunc()
//	get := http.HandlerFunc(i)
//}



//func main()  {
//	s := myString("Mike")
//	var infs Sayer
//	var pinfs pSayer
//
//	infs = s
//	infs = &s
//
//	//pinfs = s
//	pinfs = &s
//	fmt.Println(infs, pinfs)
//
//
//	var stack []interface{}
//	stack = append(stack, "你好啊", 11, true)
//	fmt.Println(stack)
//}

//func main()  {
//	e1 := T1{Employee{"Tom", 1}, 10000, 20000, 100000}
//	e2 := T2{Employee{"Jack", 2}, 8000, 15000}
//	e3 := T3{Employee{"Mary", 3}, 5000}
//	fmt.Println(CalculatorForAll(&e1, &e2, &e3))
//	fmt.Println(CalculatorForAll(e1, e2, e3))
//
//
//	var infs Calculator
//	infs = &e1
//	fmt.Println(infs.CalculatorForOne())
//
//	fmt.Println("你好呀")
//	fmt.Fprint(os.Stdout, "你好")
//}




//func test(temp interface{})  {
//	val, ok := temp.(string)
//	fmt.Println(val, ok)
//	//val:= temp.(string)
//	//fmt.Println(val)
//	//val:= temp.(type)
//	//fmt.Println(val)
//}
//
//func test1(temp interface{})  {
//	switch temp.(type) {
//	case int:
//		fmt.Println("is int")
//	case bool:
//		fmt.Println("is bool")
//	case string:
//		fmt.Println("is string")
//	default:
//		fmt.Println("nothing")
//	}
//}
//
//type Animal interface {
//	Say(content string)
//}
//
//type Cat struct {
//	Name string
//}
//
//
//
//type Dog struct {
//	Name string
//}
//
//type Shaper interface {
//	Area() float64
//}
//
//// Square struct类型
//type Square struct {
//	length float64
//}
//
//// Square类型实现Shaper中的方法Area()
//func (s Square) Area() float64 {
//	return s.length * s.length
//}
//
//func main()  {
//	//test("12345")
//	//test(12345)
//	//
//	//test1(12345)
//	//test1("12345")
//	//test1(true)
//	//test1([]int{1})
//	var intfs1, intfs2, intfs3 interface{}
//
//	var i int = 10
//
//	intfs1 = i
//	temp, ok := intfs1.(int)
//	fmt.Println(temp, ok)
//
//	pi := new(int)
//	*pi = 10
//	intfs2 = pi
//	temp, ok = intfs2.(*int)
//	fmt.Println(temp, ok)
//
//	pCat := new(Cat)
//	pCat.Name = "Tom"
//	intfs3 = pCat
//	temp, ok = intfs3.(*Cat)
//	fmt.Println(temp, ok)
//
//	var ins1, ins2 Shaper
//
//	// 指针类型的实例
//	s1 := new(Square)
//	s1.length = 3.0
//	ins1 = s1
//	if v, ok := ins1.(*Square); ok {
//		fmt.Printf("ins1: %T\n", v)
//	}
//
//	// 值类型的实例
//	s2 := Square{4.0}
//	ins2 = s2
//	if v, ok := ins2.(Square); ok {
//		fmt.Printf("ins2: %T\n", v)
//	}
//
//
//}


//import (
//	"tested"
//)
//
//func main()  {
//	//tested.Foo()  // 错误编译器会提醒
//	foo.Foo()
//
//}
//func minIncrementForUnique(A []int) int {
//	sort.Ints(A)
//	fmt.Println(A)
//	ans := 0
//	for i:=1; i<len(A); {
//		if A[i] == A[i-1] {
//			A[i]++
//			ans++
//		} else {
//			i++
//		}
//	}
//	return ans
//}
//
//func main()  {
//	A := []int{3,2,1,2,1,7}
//	fmt.Println(minIncrementForUnique(A))
//}

//type ByteSize float64
//
//type ByteSlice []byte
//
//func (p *ByteSlice) Append(data []byte) {
//	slice := *p
//	l := len(slice)
//	if l + len(data) > cap(slice) {  // 重新分配
//		// 为未来的增长,双重分配所需的内容.
//		newSlice := make([]byte, (l+len(data))*2)
//		// copy函数是预先声明的，适用于任何切片类型。
//		copy(newSlice, slice)
//		slice = newSlice
//	}
//	slice = slice[0:l+len(data)]
//	copy(slice[l:], data)
//	*p = slice
//}
//
//func (p *ByteSlice) Write(data []byte) (n int, err error) {
//	slice := *p
//	l := len(slice)
//	if l + len(data) > cap(slice) {  // 重新分配
//		// 为未来的增长,双重分配所需的内容.
//		newSlice := make([]byte, (l+len(data))*2)
//		// copy函数是预先声明的，适用于任何切片类型。
//		copy(newSlice, slice)
//		slice = newSlice
//	}
//	slice = slice[0:l+len(data)]
//	copy(slice[l:], data)
//	*p = slice
//	return len(data), nil
//}
//
//func main()  {
//	b := ByteSlice{}
//	fmt.Fprintf(&b, "hello world!")
//	b.Append([]byte("bullshit!"))
//	fmt.Println(string(b))
//}



//const (
//	_           = iota // 通过赋予空白标识符来忽略第一个值
//	KB ByteSize = 1 << (10 * iota)
//	MB
//	GB
//	TB
//	PB
//	EB
//	ZB
//	YB
//)
//
//func (b ByteSize) String() string {
//	switch {
//	case b >= YB:
//		return fmt.Sprintf("%.2fYB", b/YB)
//	case b >= ZB:
//		return fmt.Sprintf("%.2fZB", b/ZB)
//	case b >= EB:
//		return fmt.Sprintf("%.2fEB", b/EB)
//	case b >= PB:
//		return fmt.Sprintf("%.2fPB", b/PB)
//	case b >= TB:
//		return fmt.Sprintf("%.2fTB", b/TB)
//	case b >= GB:
//		return fmt.Sprintf("%.2fGB", b/GB)
//	case b >= MB:
//		return fmt.Sprintf("%.2fMB", b/MB)
//	case b >= KB:
//		return fmt.Sprintf("%.2fKB", b/KB)
//	}
//	return fmt.Sprintf("%.2fB", b)
//}
//
//func main()  {
//	b := ByteSize(20000000000)
//	fmt.Println(b)
//}

// Person 一个人的基本信息
//type Person struct {
//	Name   string
//	Age    uint
//	Gender uint // 0表示男性，1表示女性
//}
//
//type Professor struct {
//	Person
//	id       uint       // 工号
//	students []*Student // 一个教授可以带好几个学生
//}
//
//type Student struct {
//	Person
//	id      uint // 学号
//	teacher *Professor
//}
//
//func test(s string) {
//	fmt.Println("hello in test" + s)
//}
//
//func ou() func() func() {
//	fmt.Println("outside")
//	return func() func() {
//		fmt.Println("inside")
//		return func() {
//			fmt.Println("inside inside")
//		}
//	}
//}
//
//func main()  {
//	m := make(map[string]Person)
//	m["Mike"] = Person{"Mike", 28, 1}
//
//	p, ok := m["Mike"]
//	fmt.Println(p, ok)
//	p, ok = m["Mary"]
//	fmt.Println(p, ok)
//
//	get := m["Mike"]
//	fmt.Println(get)
//	get = m["Mary"]
//	fmt.Println(get)
//
//	m1 := make(map[string]Professor)
//	m1["John"] = Professor{Person{"John", 40, 1}, 281231, []*Student{&Student{}}}
//	p1, ok := m1["John"]
//	fmt.Println(p1, ok)
//	p1, ok = m1["Mary"]
//	fmt.Println(p1, ok)
//}

//
//func main()  {
//	defer ou()
//	fmt.Println("here")
//}

//func main()  {
//	p := new(Person)
//	if p == nil {
//		fmt.Println("p is nil")
//	}
//}

//func main()  {
//	fmt.Println(3^2)
//}

//func main() {
//	for i := 0; i < 5; i++ {
//		defer func(i int) {
//			fmt.Println("hello in test" + strconv.Itoa(i))
//		}(i)
//	}
//	fmt.Println("in main")
//}

//func main()  {
//	func() {
//		defer fmt.Println("in subFunc")
//	}()
//	fmt.Println("in main")
//}

//func main()  {
//	for i:=0; i<5; i++ {
//		defer test(strconv.Itoa(i))
//	}
//	fmt.Println("hello in main")
//}

//func main() {
//	defer log.Println("defer sim lou")
//	fmt.Println("ending")
//}

//func main()  {
//	s := "Hello！Your id is 12345.And you will work for 31 days"
//	x := 0
//	for i:=0; i<len(s); i++ {
//		x, i = nextInt([]byte(s), i)
//		println(x, i)
//	}
//}
//
//
//func isDigit(b byte) bool {
//	return b>='0' && b<='9'
//}
//
//
//func nextInt(b []byte, i int) (value, nextPos int) {
//	for ; i<len(b) && !isDigit(b[i]); i++ {
//	}
//	for ; i<len(b) && isDigit(b[i]); i++ {
//		value = value*10 + int(b[i]-'0')
//	}
//	nextPos = i
//	return
//}
